﻿using System;
using System.Text;
using IAM.Interface.Model;
using System.Data;

namespace IAM.Interface.ModelExample
{
    /// <summary>
    /// 人员权限管理填充模型示例
    /// </summary>
    public class ACIManagement
    {
        #region 成员方法
        #region 获取权限模型
        /// <summary>
        /// 获取权限模型
        /// 
        /// /// 1.设定本系统的权限区域
        /// 1.1 【说明1】区域可以设置多个,单至少要有一个
        /// 1.1 【说明2】区域ID由各系统自己设定,一旦确定以后不能随意更改
        /// 1.1 【说明3】本示例中设定了两个区域
        /// 1.1 【说明4】Opeartion 区域描述系统的角色信息
        /// 1.1 【说明5】Data 区域描述数据的访问范围
        /// 1.2 将权限区域添加到区域列表
        /// 2. 设置纬度
        /// 2.1 【说明】纬度的数量要大于或等于权限区域的数量
        /// 2.2 【说明】此示例中设定为2个纬度
        /// 2.3 声明一个纬度列表
        /// 2.4 声明一个“角色”纬度
        /// 2.4.1 “角色”纬度基本信息
        /// 2.4.1.1 ID由各个系统自己设定,设定后不能更改
        /// 2.4.1.2 如果此纬度的权限有层次结构 Hierachial=true;否则Hierachial=false
        /// 2.4.1.3 如果此纬度的权限项可以多选MultiCheck=true;否则MultiCheck=false
        /// 2.4.1.3 【说明】如果纬度列表中包含多个纬度；则至少一个纬度的权限项必须单选
        /// 2.4.1.4 设定该纬度的所属的纬度区域ACSection="Operation" 
        /// 2.4.1.4 【说明】ACSection的取值必须来自权限区域
        /// 2.4.2 声明该纬度的层次列表
        /// 2.4.2 【说明】一个纬度中有可以包含多个层次,至少拥有一个层次
        /// 2.4.2.1 声明一个层次实例
        /// 2.4.2.1.1 ID 权限层次标识
        /// 2.4.2.1.1 【说明】 权限层次标识由各系统自己设定,设定后不能更改
        /// 2.4.2.1.2 Display 权限层次显示名
        /// 2.4.2.1.2 【说明】权限层次显示名由各系统自己设定,设定后不能更改
        /// 2.4.2.2 将层次实例添加到层次列表
        /// 2.4.3 声明该纬度权限项列表 
        /// 2.4.3.1 声明权限项定义
        /// 2.4.3.1.1 ID属性：权限项标识
        /// 2.4.3.1.2 Display属性：权限项显示名
        /// 2.4.3.1.3 Level属性：如果该权限维度包含多层次时需要具有该属性，该属性必须是已有的Level定义的ID
        /// 2.4.3.1.4 Parent属性：如果该权限包含多层次，该属性为其父权限项ID
        /// 2.4.3.1.4 【说明】如果该权限包含多层次并且是顶层 Parent="";
        /// 2.4.3.2 声明权限项定义【类似于 2.4.3.1】
        /// 2.4.3.3 将权限项添加到权限项列表
        /// 2.5 声明一个“POS”纬度 【过程类似 2.4不再重复描述】
        /// 2.6 将单个纬度对象添加到纬度列表中
        /// 3. 保存所有权限模型定义
        /// 3.1 MultiSection  描述权限模型是否存在多个权限区
        /// 3.2 设置权限模型中权限区定义列表，包含1个或多个权限区的描述
        /// 3.3 设置权限模型中所有权限维度的列表
        /// 4.返回权限模型
        /// </summary>
        /// <returns>所有的权限模型</returns>
        public ACMMode GetACIModel()
        {
            //#region 设置权限区域
            ////1.设定本系统的权限区域
            //ACSections acsections = new ACSections();
            ////1.1 【说明1】区域可以设置多个,单至少要有一个
            ////1.1 【说明2】区域ID由各系统自己设定,一旦确定以后不能随意更改
            ////1.1 【说明3】本示例中设定了两个区域
            ////1.1 【说明4】Opeartion 区域描述系统的角色信息
            ////1.1 【说明5】Data 区域描述数据的访问范围
            //ACSection acsectionRole = new ACSection();
            //acsectionRole.ID = "Opeartion";

            //ACSection acsectionData = new ACSection();
            //acsectionData.ID = "Data";

            ////1.2 将权限区域添加到区域列表

            //acsections.Items.Add(acsectionRole);
            //acsections.Items.Add(acsectionData);
            //#endregion
            //#region 设置纬度
            ////2. 设置纬度
            ////2.1 【说明】纬度的数量要大于或等于权限区域的数量
            ////2.2 【说明】此示例中设定为2个纬度

            ////2.3 声明一个纬度列表
            //Dimensions dimensions = new Dimensions();
            //#region DimensionRole
            ////2.4 声明一个“角色”纬度
            //Dimension dimensionRole = new Dimension();
            ////2.4.1 “角色”纬度基本信息
            ////2.4.1.1 ID由各个系统自己设定,设定后不能更改
            //dimensionRole.ID = "Role";
            //dimensionRole.Display = "Role"; 
            ////2.4.1.2 如果此纬度的权限有层次结构 Hierachial=true;否则Hierachial=false
            //dimensionRole.Hierachical = false;
            ////2.4.1.3 如果此纬度的权限项可以多选MultiCheck=true;否则MultiCheck=false
            ////2.4.1.3 【说明】如果纬度列表中包含多个纬度；则至少一个纬度的权限项必须单选
            //dimensionRole.MultiCheck = false;
            ////2.4.1.4 设定该纬度的所属的纬度区域ACSection="Operation" 
            ////2.4.1.4 【说明】ACSection的取值必须来自权限区域
            //dimensionRole.ACSection = new ACSection();
            //dimensionRole.ACSection.ID = "Operation";

            ////2.4.2 声明该纬度的层次列表
            ////2.4.2 【说明】一个纬度中有可以包含多个层次,至少拥有一个层次
            //dimensionRole.DimensionLevels = new DimensionLevels();
            ////2.4.2.1 声明一个层次实例
            //DimensionLevel dimensionLevelRole1 = new DimensionLevel();
            ////2.4.2.1.1 ID 权限层次标识
            ////2.4.2.1.1 【说明】 权限层次标识由各系统自己设定,设定后不能更改
            //dimensionLevelRole1.ID = "Role";
            ////2.4.2.1.2 Display 权限层次显示名
            ////2.4.2.1.2 【说明】权限层次显示名由各系统自己设定,设定后不能更改
            //dimensionLevelRole1.Display = "Role";

            ////2.4.2.2 将层次实例添加到层次列表
            //dimensionRole.DimensionLevels.Items.Add(dimensionLevelRole1);

            ////2.4.3 声明该纬度权限项列表 
            //dimensionRole.ACItems = new ACItems();
            ////2.4.3.1 声明权限项定义
            //ACItem acitemRole1 = new ACItem();
            ////2.4.3.1.1 ID属性：权限项标识
            //acitemRole1.ID = "Project Manager";
            ////2.4.3.1.2 Display属性：权限项显示名
            //acitemRole1.Display = "Project Manager";
            ////2.4.3.1.3 Level属性：如果该权限维度包含多层次时需要具有该属性，该属性必须是已有的Level定义的ID
            //acitemRole1.DimensionLevel = null;
            ////2.4.3.1.4 Parent属性：如果该权限包含多层次，该属性为其父权限项ID
            ////2.4.3.1.4 【说明】如果该权限包含多层次并且是顶层 Parent="";
            //acitemRole1.Parent = null;

            ////2.4.3.2 声明权限项定义【类似于 2.4.3.1】
            //ACItem acitemRole2 = new ACItem();
            //acitemRole2.ID = "Department Manager";
            //acitemRole2.Display = "Department Head";
            //acitemRole2.DimensionLevel = null;
            //acitemRole2.Parent = null;

            ////2.4.3.3 将权限项添加到权限项列表
            //dimensionRole.ACItems.Items.Add(acitemRole1);
            //dimensionRole.ACItems.Items.Add(acitemRole2);

            //#endregion
            //#region DimensionPos
            ////2.5 声明一个“POS”纬度
            //Dimension dimensionPos = new Dimension();
            ////2.5.1 “POS”纬度基本信息
            ////2.5.1.1 ID由各个系统自己设定,设定后不能更改
            //dimensionPos.ID = "POS";
            //dimensionPos.Display = "ORGANIZATION";
            ////2.5.1.2 如果此纬度的权限有层次结构 Hierachial=true;否则Hierachial=false
            //dimensionPos.Hierachical = true;
            ////2.5.1.3 如果此纬度的权限项可以多选MultiCheck=true;否则MultiCheck=false
            ////2.5.1.3 【说明】如果纬度列表中包含多个纬度；则至少一个纬度的权限项必须单选
            //dimensionPos.MultiCheck = true;
            ////2.5.1.4 设定该纬度的所属的纬度区域ACSection="Operation" 
            ////2.5.1.4 【说明】ACSection的取值必须来自权限区域
            //dimensionPos.ACSection = new ACSection();
            //dimensionPos.ACSection.ID = "Data";

            ////2.5.2 声明该纬度的层次列表
            ////2.5.2 【说明】一个纬度中有可以包含多个层次,至少拥有一个层次
            //dimensionPos.DimensionLevels = new DimensionLevels();
            ////2.5.2.1 声明一个层次实例
            //DimensionLevel dimensionLevelPos1 = new DimensionLevel();
            ////2.5.2.1.1 ID 权限层次标识
            ////2.5.2.1.1 【说明】 权限层次标识由各系统自己设定,设定后不能更改
            //dimensionLevelPos1.ID = "BG";
            ////2.5.2.1.2 Display 权限层次显示名
            ////2.5.2.1.2 【说明】权限层次显示名由各系统自己设定,设定后不能更改
            //dimensionLevelPos1.Display = "Business Group";

            //DimensionLevel dimensionLevelPos2 = new DimensionLevel();
            //dimensionLevelPos2.ID = "BD";
            //dimensionLevelPos2.Display = "Business Department";

            ////2.5.2.2 将层次实例添加到层次列表
            //dimensionPos.DimensionLevels.Items.Add(dimensionLevelPos1);
            //dimensionPos.DimensionLevels.Items.Add(dimensionLevelPos2);

            ////2.5.3 声明该纬度权限项列表 
            //dimensionPos.ACItems = new ACItems();
            ////2.5.3.1 声明权限项定义
            //ACItem acitemPos1 = new ACItem();
            ////2.5.3.1.1 ID属性：权限项标识
            //acitemPos1.ID = "G007";
            ////2.5.3.1.2 Display属性：权限项显示名
            //acitemPos1.Display = "SM-D";
            ////2.5.3.1.3 Level属性：如果该权限维度包含多层次时需要具有该属性，该属性必须是已有的Level定义的
            //acitemPos1.DimensionLevel = dimensionLevelPos1;
            ////2.5.3.1.4 Parent属性：如果该权限包含多层次，该属性为其父权限项ID
            ////2.5.3.1.4 【说明】如果该权限包含多层次并且是顶层 Parent="";
            //acitemPos1.Parent = null;

            ////2.5.3.2 声明权限项定义【类似于 2.4.3.1】
            //ACItem acitemPos2= new ACItem();
            //acitemPos2.ID = "D010";
            //acitemPos2.Display = "BSH";
            //acitemPos2.DimensionLevel = dimensionLevelPos2;
            //acitemPos2.Parent = acitemPos1;

            ////2.5.3.3 将权限项添加到权限项列表
            //dimensionPos.ACItems.Items.Add(acitemPos1);
            //dimensionPos.ACItems.Items.Add(acitemPos2);

            //#endregion

            ////2.6 将单个纬度对象添加到纬度列表中
            //dimensions.Items.Add(dimensionRole);
            //dimensions.Items.Add(dimensionPos);
            //#endregion
            //#region 保存所有权限模型定义
            ////3. 保存所有权限模型定义
            //ACMMode acmmode = new ACMMode();
            ////3.1 MultiSection  描述权限模型是否存在多个权限区
            //acmmode.MultiSection = true;
            ////3.2 设置权限模型中权限区定义列表，包含1个或多个权限区的描述
            //acmmode.SectionList = acsections;
            ////3.3 设置权限模型中所有权限维度的列表
            //acmmode.DimensionList = dimensions;
            //#endregion
            //#region 返回权限模型
            ////4.返回权限模型
            //return acmmode;
            //#endregion



            #region 设置权限区域
            //1.设定本系统的权限区域
            ACSections acsections = new ACSections();
            //1.1 【说明1】区域可以设置多个,单至少要有一个
            //1.1 【说明2】区域ID由各系统自己设定,一旦确定以后不能随意更改
            //1.1 【说明3】本示例中设定了两个区域
            //1.1 【说明4】Opeartion 区域描述系统的角色信息
            //1.1 【说明5】Data 区域描述数据的访问范围
            ACSection acsectionMain = new ACSection();
            acsectionMain.ID = "Main";

            //1.2 将权限区域添加到区域列表

            acsections.Items.Add(acsectionMain);
            #endregion
            #region 设置纬度
            //2. 设置纬度
            //2.1 【说明】纬度的数量要大于或等于权限区域的数量
            //2.2 【说明】此示例中设定为2个纬度

            //2.3 声明一个纬度列表
            Dimensions dimensions = new Dimensions();
            #region DimensionRole
            //2.4 声明一个“角色”纬度
            Dimension dimensionRole = new Dimension();
            //2.4.1 “角色”纬度基本信息
            //2.4.1.1 ID由各个系统自己设定,设定后不能更改
            dimensionRole.ID = "Role";
            dimensionRole.Display = "Role";
            //2.4.1.2 如果此纬度的权限有层次结构 Hierachial=true;否则Hierachial=false
            dimensionRole.Hierachical = false;
            //2.4.1.3 如果此纬度的权限项可以多选MultiCheck=true;否则MultiCheck=false
            //2.4.1.3 【说明】如果纬度列表中包含多个纬度；则至少一个纬度的权限项必须单选
            dimensionRole.MultiCheck = true;
            //2.4.1.4 设定该纬度的所属的纬度区域ACSection="Operation" 
            //2.4.1.4 【说明】ACSection的取值必须来自权限区域
            dimensionRole.ACSection = acsectionMain;

            //2.4.2 声明该纬度的层次列表
            //2.4.2 【说明】一个纬度中有可以包含多个层次,至少拥有一个层次
            dimensionRole.DimensionLevels = new DimensionLevels();
            //2.4.2.1 声明一个层次实例
            DimensionLevel dimensionLevelRole = new DimensionLevel();
            //2.4.2.1.1 ID 权限层次标识
            //2.4.2.1.1 【说明】 权限层次标识由各系统自己设定,设定后不能更改
            dimensionLevelRole.ID = "Role";
            //2.4.2.1.2 Display 权限层次显示名
            //2.4.2.1.2 【说明】权限层次显示名由各系统自己设定,设定后不能更改
            dimensionLevelRole.Display = "Role";

            //2.4.2.2 将层次实例添加到层次列表
            dimensionRole.DimensionLevels.Items.Add(dimensionLevelRole);

            //2.4.3 声明该纬度权限项列表 
            dimensionRole.ACItems = new ACItems();
            //2.4.3.1 声明权限项定义
            BEGDC.PreContract.BLL.IRole roleService = (BEGDC.PreContract.BLL.IRole)BEGDC.Utility.Castle.AppContainer.Instance[BEGDC.PreContract.BLL.Services.CONST_Role_Service];
            System.Data.DataTable dt = roleService.GetRole_DataTable(string.Empty);
            foreach(System.Data.DataRow dr in dt.Rows)
            {

                ACItem acitem = new ACItem();
                acitem.Attr1 = "set";
                //2.4.3.1.1 ID属性：权限项标识
                acitem.ID = ResponseLocalLibrary.Business.Prefix_Dimension.Role.ToString() + "_" +  dr[BEGDC.PreContract.DAL.Role.CONST_RoleID].ToString();
                //2.4.3.1.2 Display属性：权限项显示名
                acitem.Display = dr[BEGDC.PreContract.DAL.Role.CONST_Description].ToString();
                //2.4.3.1.3 Level属性：如果该权限维度包含多层次时需要具有该属性，该属性必须是已有的Level定义的ID
                acitem.DimensionLevel = null;
                //2.4.3.1.4 Parent属性：如果该权限包含多层次，该属性为其父权限项ID
                //2.4.3.1.4 【说明】如果该权限包含多层次并且是顶层 Parent="";
                acitem.Parent = null;

                //2.4.3.3 将权限项添加到权限项列表
                dimensionRole.ACItems.Items.Add(acitem);
            }

            #endregion

            #region DimensionBD
            //2.4 声明一个“角色”纬度
            Dimension dimensionBD = new Dimension();
            //2.4.1 “角色”纬度基本信息
            //2.4.1.1 ID由各个系统自己设定,设定后不能更改
            dimensionBD.ID = "BD";
            dimensionBD.Display = "BD";
            //2.4.1.2 如果此纬度的权限有层次结构 Hierachial=true;否则Hierachial=false
            dimensionBD.Hierachical = false;
            //2.4.1.3 如果此纬度的权限项可以多选MultiCheck=true;否则MultiCheck=false
            //2.4.1.3 【说明】如果纬度列表中包含多个纬度；则至少一个纬度的权限项必须单选
            dimensionBD.MultiCheck = true;
            //2.4.1.4 设定该纬度的所属的纬度区域ACSection="Operation" 
            //2.4.1.4 【说明】ACSection的取值必须来自权限区域
            dimensionBD.ACSection = acsectionMain;

            //2.4.2 声明该纬度的层次列表
            //2.4.2 【说明】一个纬度中有可以包含多个层次,至少拥有一个层次
            dimensionBD.DimensionLevels = new DimensionLevels();
            //2.4.2.1 声明一个层次实例
            DimensionLevel dimensionLevelBD = new DimensionLevel();
            //2.4.2.1.1 ID 权限层次标识
            //2.4.2.1.1 【说明】 权限层次标识由各系统自己设定,设定后不能更改
            dimensionLevelBD.ID = "BD";
            //2.4.2.1.2 Display 权限层次显示名
            //2.4.2.1.2 【说明】权限层次显示名由各系统自己设定,设定后不能更改
            dimensionLevelBD.Display = "BD";

            //2.4.2.2 将层次实例添加到层次列表
            dimensionBD.DimensionLevels.Items.Add(dimensionLevelBD);

            //2.4.3 声明该纬度权限项列表 
            dimensionBD.ACItems = new ACItems();
            //2.4.3.1 声明权限项定义
            BEGDC.PreContract.BLL.IBD BDService = (BEGDC.PreContract.BLL.IBD)BEGDC.Utility.Castle.AppContainer.Instance[BEGDC.PreContract.BLL.Services.CONST_BD_Service];
            System.Data.DataTable dtBD = BDService.GetBD_DataTable(string.Empty);
            foreach (System.Data.DataRow dr in dtBD.Rows)
            {

                ACItem acitem = new ACItem();
                //2.4.3.1.1 ID属性：权限项标识
                acitem.ID = ResponseLocalLibrary.Business.Prefix_Dimension.BD.ToString() + "_" + dr[BEGDC.PreContract.DAL.BD.CONST_BDID].ToString();
                //2.4.3.1.2 Display属性：权限项显示名
                acitem.Display = dr[BEGDC.PreContract.DAL.BD.CONST_BDCode].ToString();
                //2.4.3.1.3 Level属性：如果该权限维度包含多层次时需要具有该属性，该属性必须是已有的Level定义的ID
                acitem.DimensionLevel = null;
                //2.4.3.1.4 Parent属性：如果该权限包含多层次，该属性为其父权限项ID
                //2.4.3.1.4 【说明】如果该权限包含多层次并且是顶层 Parent="";
                acitem.Parent = null;

                //2.4.3.3 将权限项添加到权限项列表
                dimensionBD.ACItems.Items.Add(acitem);
            }

            #endregion

            #region DimensionCAT
            //2.4 声明一个“角色”纬度
            Dimension dimensionCAT = new Dimension();
            //2.4.1 “角色”纬度基本信息
            //2.4.1.1 ID由各个系统自己设定,设定后不能更改
            dimensionCAT.ID = "CAT";
            dimensionCAT.Display = "CAT";
            //2.4.1.2 如果此纬度的权限有层次结构 Hierachial=true;否则Hierachial=false
            dimensionCAT.Hierachical = false;
            //2.4.1.3 如果此纬度的权限项可以多选MultiCheck=true;否则MultiCheck=false
            //2.4.1.3 【说明】如果纬度列表中包含多个纬度；则至少一个纬度的权限项必须单选
            dimensionCAT.MultiCheck = true;
            //2.4.1.4 设定该纬度的所属的纬度区域ACSection="Operation" 
            //2.4.1.4 【说明】ACSection的取值必须来自权限区域
            dimensionCAT.ACSection = acsectionMain;

            //2.4.2 声明该纬度的层次列表
            //2.4.2 【说明】一个纬度中有可以包含多个层次,至少拥有一个层次
            dimensionCAT.DimensionLevels = new DimensionLevels();
            //2.4.2.1 声明一个层次实例
            DimensionLevel dimensionLevelCAT = new DimensionLevel();
            //2.4.2.1.1 ID 权限层次标识
            //2.4.2.1.1 【说明】 权限层次标识由各系统自己设定,设定后不能更改
            dimensionLevelCAT.ID = "CAT";
            //2.4.2.1.2 Display 权限层次显示名
            //2.4.2.1.2 【说明】权限层次显示名由各系统自己设定,设定后不能更改
            dimensionLevelCAT.Display = "CAT";

            //2.4.2.2 将层次实例添加到层次列表
            dimensionCAT.DimensionLevels.Items.Add(dimensionLevelCAT);

            //2.4.3 声明该纬度权限项列表 
            dimensionCAT.ACItems = new ACItems();
            //2.4.3.1 声明权限项定义
            BEGDC.PreContract.BLL.ICAT CATService = (BEGDC.PreContract.BLL.ICAT)BEGDC.Utility.Castle.AppContainer.Instance[BEGDC.PreContract.BLL.Services.CONST_CAT_Service];
            System.Data.DataTable dtCAT = CATService.GetCAT_DataTable(string.Empty);
            foreach (System.Data.DataRow dr in dtCAT.Rows)
            {

                ACItem acitem = new ACItem();
                //2.4.3.1.1 ID属性：权限项标识
                acitem.ID = ResponseLocalLibrary.Business.Prefix_Dimension.CAT.ToString() + "_" + dr[BEGDC.PreContract.DAL.CAT.CONST_CATID].ToString();
                //2.4.3.1.2 Display属性：权限项显示名
                acitem.Display = dr[BEGDC.PreContract.DAL.CAT.CONST_CATCode].ToString();
                //2.4.3.1.3 Level属性：如果该权限维度包含多层次时需要具有该属性，该属性必须是已有的Level定义的ID
                acitem.DimensionLevel = null;
                //2.4.3.1.4 Parent属性：如果该权限包含多层次，该属性为其父权限项ID
                //2.4.3.1.4 【说明】如果该权限包含多层次并且是顶层 Parent="";
                acitem.Parent = null;

                //2.4.3.3 将权限项添加到权限项列表
                dimensionCAT.ACItems.Items.Add(acitem);
            }

            #endregion


            #region DimensionProvince
            //2.4 声明一个“角色”纬度
            Dimension dimensionProvince = new Dimension();
            //2.4.1 “角色”纬度基本信息
            //2.4.1.1 ID由各个系统自己设定,设定后不能更改
            dimensionProvince.ID = "Province";
            dimensionProvince.Display = "Province";
            //2.4.1.2 如果此纬度的权限有层次结构 Hierachial=true;否则Hierachial=false
            dimensionProvince.Hierachical = false;
            //2.4.1.3 如果此纬度的权限项可以多选MultiCheck=true;否则MultiCheck=false
            //2.4.1.3 【说明】如果纬度列表中包含多个纬度；则至少一个纬度的权限项必须单选
            dimensionProvince.MultiCheck = true;
            //2.4.1.4 设定该纬度的所属的纬度区域ACSection="Operation" 
            //2.4.1.4 【说明】ACSection的取值必须来自权限区域
            dimensionProvince.ACSection = acsectionMain;

            //2.4.2 声明该纬度的层次列表
            //2.4.2 【说明】一个纬度中有可以包含多个层次,至少拥有一个层次
            dimensionProvince.DimensionLevels = new DimensionLevels();
            //2.4.2.1 声明一个层次实例
            DimensionLevel dimensionLevelProvince = new DimensionLevel();
            //2.4.2.1.1 ID 权限层次标识
            //2.4.2.1.1 【说明】 权限层次标识由各系统自己设定,设定后不能更改
            dimensionLevelProvince.ID = "Province";
            //2.4.2.1.2 Display 权限层次显示名
            //2.4.2.1.2 【说明】权限层次显示名由各系统自己设定,设定后不能更改
            dimensionLevelProvince.Display = "Province";

            //2.4.2.2 将层次实例添加到层次列表
            dimensionProvince.DimensionLevels.Items.Add(dimensionLevelProvince);

            //2.4.3 声明该纬度权限项列表 
            dimensionProvince.ACItems = new ACItems();
            //2.4.3.1 声明权限项定义
            BEGDC.PreContract.BLL.IProvince ProvinceService = (BEGDC.PreContract.BLL.IProvince)BEGDC.Utility.Castle.AppContainer.Instance[BEGDC.PreContract.BLL.Services.CONST_Province_Service];
            System.Data.DataTable dtProvince = ProvinceService.GetProvince_DataTable(string.Empty);
            foreach (System.Data.DataRow dr in dtProvince.Rows)
            {

                ACItem acitem = new ACItem();
                //2.4.3.1.1 ID属性：权限项标识
                acitem.ID = ResponseLocalLibrary.Business.Prefix_Dimension.Province.ToString() + "_" + dr[BEGDC.PreContract.DAL.Province.CONST_ProvinceID].ToString();
                //2.4.3.1.2 Display属性：权限项显示名
                acitem.Display = dr[BEGDC.PreContract.DAL.Province.CONST_ProvinceCode].ToString() + " " + dr[BEGDC.PreContract.DAL.Province.CONST_ProvinceCName].ToString();
                //2.4.3.1.3 Level属性：如果该权限维度包含多层次时需要具有该属性，该属性必须是已有的Level定义的ID
                acitem.DimensionLevel = null;
                //2.4.3.1.4 Parent属性：如果该权限包含多层次，该属性为其父权限项ID
                //2.4.3.1.4 【说明】如果该权限包含多层次并且是顶层 Parent="";
                acitem.Parent = null;

                //2.4.3.3 将权限项添加到权限项列表
                dimensionProvince.ACItems.Items.Add(acitem);
            }

            #endregion

            #region DimensionASBOrLucent
            //2.4 声明一个“角色”纬度
            Dimension dimensionASBOrLucent = new Dimension();
            //2.4.1 “角色”纬度基本信息
            //2.4.1.1 ID由各个系统自己设定,设定后不能更改
            dimensionASBOrLucent.ID = "ASBOrLucent";
            dimensionASBOrLucent.Display = "ASBOrLucent";
            //2.4.1.2 如果此纬度的权限有层次结构 Hierachial=true;否则Hierachial=false
            dimensionASBOrLucent.Hierachical = false;
            //2.4.1.3 如果此纬度的权限项可以多选MultiCheck=true;否则MultiCheck=false
            //2.4.1.3 【说明】如果纬度列表中包含多个纬度；则至少一个纬度的权限项必须单选
            dimensionASBOrLucent.MultiCheck = false;
            //2.4.1.4 设定该纬度的所属的纬度区域ACSection="Operation" 
            //2.4.1.4 【说明】ACSection的取值必须来自权限区域
            dimensionASBOrLucent.ACSection = acsectionMain;

            //2.4.2 声明该纬度的层次列表
            //2.4.2 【说明】一个纬度中有可以包含多个层次,至少拥有一个层次
            dimensionASBOrLucent.DimensionLevels = new DimensionLevels();
            //2.4.2.1 声明一个层次实例
            DimensionLevel dimensionLevelASBOrLucent = new DimensionLevel();
            //2.4.2.1.1 ID 权限层次标识
            //2.4.2.1.1 【说明】 权限层次标识由各系统自己设定,设定后不能更改
            dimensionLevelASBOrLucent.ID = "ASBOrLucent";
            //2.4.2.1.2 Display 权限层次显示名
            //2.4.2.1.2 【说明】权限层次显示名由各系统自己设定,设定后不能更改
            dimensionLevelASBOrLucent.Display = "ASBOrLucent";

            //2.4.2.2 将层次实例添加到层次列表
            dimensionASBOrLucent.DimensionLevels.Items.Add(dimensionLevelASBOrLucent);

            //2.4.3 声明该纬度权限项列表 
            dimensionASBOrLucent.ACItems = new ACItems();
            //2.4.3.1 声明权限项定义
            
            ACItem acitemASB = new ACItem();
            acitemASB.ID = ResponseLocalLibrary.Business.Prefix_Dimension.ASBOrLucent.ToString() + "_" +  "0";
            acitemASB.Display = "ASB";
            acitemASB.DimensionLevel = null;
            acitemASB.Parent = null;

            ACItem acitemLucent = new ACItem();
            acitemLucent.ID = ResponseLocalLibrary.Business.Prefix_Dimension.ASBOrLucent.ToString() + "_" + "1";
            acitemLucent.Display = "Lucent";
            acitemLucent.DimensionLevel = null;
            acitemLucent.Parent = null;

            ACItem acitemAll = new ACItem();
            acitemAll.ID = ResponseLocalLibrary.Business.Prefix_Dimension.ASBOrLucent.ToString() + "_" + "2";
            acitemAll.Display = "All";
            acitemAll.DimensionLevel = null;
            acitemAll.Parent = null;


            //2.4.3.3 将权限项添加到权限项列表
            dimensionASBOrLucent.ACItems.Items.Add(acitemAll);
            dimensionASBOrLucent.ACItems.Items.Add(acitemASB);
            dimensionASBOrLucent.ACItems.Items.Add(acitemLucent);


            #endregion


            #region DimensionComments
            //2.4 声明一个“角色”纬度
            Dimension dimensionComments = new Dimension();
            //2.4.1 “角色”纬度基本信息
            //2.4.1.1 ID由各个系统自己设定,设定后不能更改
            dimensionComments.ID = "Comments";
            dimensionComments.Display = "Write Comments";
            //2.4.1.2 如果此纬度的权限有层次结构 Hierachial=true;否则Hierachial=false
            dimensionComments.Hierachical = false;
            //2.4.1.3 如果此纬度的权限项可以多选MultiCheck=true;否则MultiCheck=false
            //2.4.1.3 【说明】如果纬度列表中包含多个纬度；则至少一个纬度的权限项必须单选
            dimensionComments.MultiCheck = false;
            //2.4.1.4 设定该纬度的所属的纬度区域ACSection="Operation" 
            //2.4.1.4 【说明】ACSection的取值必须来自权限区域
            dimensionComments.ACSection = acsectionMain;

            //2.4.2 声明该纬度的层次列表
            //2.4.2 【说明】一个纬度中有可以包含多个层次,至少拥有一个层次
            dimensionComments.DimensionLevels = new DimensionLevels();
            //2.4.2.1 声明一个层次实例
            DimensionLevel dimensionLevelComments = new DimensionLevel();
            //2.4.2.1.1 ID 权限层次标识
            //2.4.2.1.1 【说明】 权限层次标识由各系统自己设定,设定后不能更改
            dimensionLevelComments.ID = "Comments";
            //2.4.2.1.2 Display 权限层次显示名
            //2.4.2.1.2 【说明】权限层次显示名由各系统自己设定,设定后不能更改
            dimensionLevelComments.Display = "Comments";

            //2.4.2.2 将层次实例添加到层次列表
            dimensionComments.DimensionLevels.Items.Add(dimensionLevelComments);

            //2.4.3 声明该纬度权限项列表 
            dimensionComments.ACItems = new ACItems();
            //2.4.3.1 声明权限项定义

            ACItem acitemComments_Yes = new ACItem();
            acitemComments_Yes.ID = ResponseLocalLibrary.Business.Prefix_Dimension.Comment.ToString() + "_" + "1";
            acitemComments_Yes.Display = "Yes";
            acitemComments_Yes.DimensionLevel = null;
            acitemComments_Yes.Parent = null;

            ACItem acitemComments_No = new ACItem();
            acitemComments_No.ID = ResponseLocalLibrary.Business.Prefix_Dimension.Comment.ToString() + "_" + "0";
            acitemComments_No.Display = "No";
            acitemComments_No.DimensionLevel = null;
            acitemComments_No.Parent = null;

            //2.4.3.3 将权限项添加到权限项列表
            dimensionComments.ACItems.Items.Add(acitemComments_Yes);
            dimensionComments.ACItems.Items.Add(acitemComments_No);


            #endregion


            #region DimensionDownLoad
            //2.4 声明一个“角色”纬度
            Dimension dimensionDownLoad = new Dimension();
            //2.4.1 “角色”纬度基本信息
            //2.4.1.1 ID由各个系统自己设定,设定后不能更改
            dimensionDownLoad.ID = "DownLoad";
            dimensionDownLoad.Display = "DownLoad Overdue Data";
            //2.4.1.2 如果此纬度的权限有层次结构 Hierachial=true;否则Hierachial=false
            dimensionDownLoad.Hierachical = false;
            //2.4.1.3 如果此纬度的权限项可以多选MultiCheck=true;否则MultiCheck=false
            //2.4.1.3 【说明】如果纬度列表中包含多个纬度；则至少一个纬度的权限项必须单选
            dimensionDownLoad.MultiCheck = false;
            //2.4.1.4 设定该纬度的所属的纬度区域ACSection="Operation" 
            //2.4.1.4 【说明】ACSection的取值必须来自权限区域
            dimensionDownLoad.ACSection = acsectionMain;

            //2.4.2 声明该纬度的层次列表
            //2.4.2 【说明】一个纬度中有可以包含多个层次,至少拥有一个层次
            dimensionDownLoad.DimensionLevels = new DimensionLevels();
            //2.4.2.1 声明一个层次实例
            DimensionLevel dimensionLevelDownLoad = new DimensionLevel();
            //2.4.2.1.1 ID 权限层次标识
            //2.4.2.1.1 【说明】 权限层次标识由各系统自己设定,设定后不能更改
            dimensionLevelDownLoad.ID = "DownLoad";
            //2.4.2.1.2 Display 权限层次显示名
            //2.4.2.1.2 【说明】权限层次显示名由各系统自己设定,设定后不能更改
            dimensionLevelDownLoad.Display = "DownLoad";

            //2.4.2.2 将层次实例添加到层次列表
            dimensionDownLoad.DimensionLevels.Items.Add(dimensionLevelDownLoad);

            //2.4.3 声明该纬度权限项列表 
            dimensionDownLoad.ACItems = new ACItems();
            //2.4.3.1 声明权限项定义

            ACItem acitemDownLoad_Yes = new ACItem();
            acitemDownLoad_Yes.ID = ResponseLocalLibrary.Business.Prefix_Dimension.Download.ToString() + "_" + "1";
            acitemDownLoad_Yes.Display = "Yes";
            acitemDownLoad_Yes.DimensionLevel = null;
            acitemDownLoad_Yes.Parent = null;

            ACItem acitemDownLoad_No = new ACItem();
            acitemDownLoad_No.ID = ResponseLocalLibrary.Business.Prefix_Dimension.Download.ToString() + "_" + "0";
            acitemDownLoad_No.Display = "No";
            acitemDownLoad_No.DimensionLevel = null;
            acitemDownLoad_No.Parent = null;

            //2.4.3.3 将权限项添加到权限项列表
            dimensionDownLoad.ACItems.Items.Add(acitemDownLoad_Yes);
            dimensionDownLoad.ACItems.Items.Add(acitemDownLoad_No);


            #endregion
            //2.6 将单个纬度对象添加到纬度列表中
            dimensions.Items.Add(dimensionRole);
            dimensions.Items.Add(dimensionCAT);
            dimensions.Items.Add(dimensionBD);
            dimensions.Items.Add(dimensionProvince);
            dimensions.Items.Add(dimensionASBOrLucent);
            dimensions.Items.Add(dimensionComments);
            dimensions.Items.Add(dimensionDownLoad);

            
            #endregion
            #region 保存所有权限模型定义
            //3. 保存所有权限模型定义
            ACMMode acmmode = new ACMMode();
            //3.1 MultiSection  描述权限模型是否存在多个权限区
            acmmode.MultiSection = false;
            //3.2 设置权限模型中权限区定义列表，包含1个或多个权限区的描述
            acmmode.SectionList = acsections;
            //3.3 设置权限模型中所有权限维度的列表
            acmmode.DimensionList = dimensions;
            #endregion
            #region 返回权限模型
            //4.返回权限模型
            return acmmode;
            #endregion
        }
        #endregion
        #region 获取用户权限信息
        /// <summary>
        /// 获取用户权限信息
        /// 
        /// /// 1.声明一个人员权限对象 aci
        /// 2.实例化aci.人员帐号对象 
        /// 3.用带入参数为aci.人员帐号对象 赋值
        /// 3.声明aci.纬度列表 ACISessions 
        /// 4. 获取本系统该人员的所有角色集合Roles
        /// 4.【说明】角色集合Roles可能是个dataset/datatable/arrylist；由各系统自己组织
        /// 5.遍历Roles集合
        /// 6. 声明一个权限描述信息实体 ACISession 
        /// 6 【说明1】如果权限模型为多权限区则可能包括多条权限描述信息ACSession
        /// 6 【说明2】本示例中权限模型为多权限区MultiSection=”TRUE”
        /// 6 【说明3】本示例中设置2个权限区 角色/访问区域
        /// 7.声明一个 权限配置项 CheckedItem ，填充“角色”的权限配置项信息
        /// 7.1 权限配置项标识 ACItemID
        /// 7.2 Value 目前均为“check”
        /// 8.根据当前的角色信息获取该角色的访问区域集合DataArrylist
        /// 9.遍历 访问区域集合DataArrylist
        /// 10.声明一个 权限配置项 CheckedItem ，填充“角色”的权限配置项信息
        /// 10.1 权限配置项标识 ACItemID
        /// 10.2 Value 目前均为“check”
        /// 11.将实体信息ACISession添加到纬度列表
        /// 12.返回人员权限对象
        /// </summary>
        /// <param name="accountinfo">人员帐号信息</param>
        /// <returns>用户的权限信息</returns>
        public ACI GetUserACI(AccountInfo accountinfo)
        {
            if (accountinfo.AppAccount == string.Empty)
            {
                throw new Exception("AppAccount can not be empty.");
            }

            //1.声明一个人员权限对象 aci
            ACI aci = new ACI();
            //2.实例化aci.人员帐号对象 
            aci.AccountInfo = new AccountInfo();
            //3.用带入参数为aci.人员帐号对象 赋值
            aci.AccountInfo.HRISEID = accountinfo.HRISEID;
            aci.AccountInfo.ADAccount = accountinfo.ADAccount;
            aci.AccountInfo.CSLAccount = accountinfo.CSLAccount;
            aci.AccountInfo.CILX500 = accountinfo.CILX500;
            aci.AccountInfo.UPI = accountinfo.UPI;
            aci.AccountInfo.AppAccount = accountinfo.AppAccount;

            //3.声明aci.纬度列表 ACISessions 
            aci.ACISessions = new ACISessions();
            //4. 获取本系统该人员的所有角色集合Roles
            //4.【说明】角色集合Roles可能是个dataset/datatable/arrylist；由各系统自己组织
            try
            {
                //#region 此段伪代码不能执行，仅仅作为说明

                //DataSet dsRoles = new DataSet();

                ////5.遍历Roles集合
                //for (int i = 0; i < dsRoles.Tables[0].Rows.Count; i++)
                //{

                //    //6. 声明一个权限描述信息实体 ACISession 
                //    //6 【说明1】如果权限模型为多权限区则可能包括多条权限描述信息ACSession
                //    //6 【说明2】本示例中权限模型为多权限区MultiSection=”TRUE”
                //    //6 【说明3】本示例中设置2个权限区 角色/访问区域
                //    ACISession acisession = new ACISession();
                //    //7.声明一个 权限配置项 CheckedItem ，填充“角色”的权限配置项信息
                //    CheckedItem checkeditemrole = new CheckedItem();
                //    //7.1 权限配置项标识 ACItemID
                //    checkeditemrole.ACItemID = dsRoles.Tables[0].Rows[i]["ACItemID"].ToString();//各个系统根据情况查找不同的字段信息
                //    //7.2 Value 目前均为“check”
                //    if (dsRoles.Tables[0].Rows[i]["Value"].ToString().ToLower() == "true")//各个系统根据情况查找不同的字段信息
                //    {
                //        checkeditemrole.Value = true;
                //    }
                //    else
                //    {
                //        checkeditemrole.Value = false;
                //    }
                //    acisession.Items.Add(checkeditemrole);//将角色权限配置项添加到权限描述信息实体 ACISession 

                //    //8.根据当前的角色信息获取该角色的访问区域集合DataArrylist
                //    DataSet datasetDataArrylist = new DataSet();//
                //    //9.遍历 访问区域集合DataArrylist
                //    for (int j = 0; j < datasetDataArrylist.Tables[0].Rows.Count; j++)
                //    {
                //        //10.声明一个 权限配置项 CheckedItem ，填充“角色”的权限配置项信息
                //        CheckedItem checkeditemData = new CheckedItem();
                //        //10.1 权限配置项标识 ACItemID
                //        checkeditemData.ACItemID = datasetDataArrylist.Tables[0].Rows[j]["ACItemID"].ToString();//各个系统根据情况查找不同的字段信息
                //        //10.2 Value 目前均为“check”
                //        if (datasetDataArrylist.Tables[0].Rows[j]["Value"].ToString().ToLower() == "true")//各个系统根据情况查找不同的字段信息
                //        {
                //            checkeditemData.Value = true;
                //        }
                //        else
                //        {
                //            checkeditemData.Value = false;
                //        }
                //        acisession.Items.Add(checkeditemData);//将访问区域权限配置项添加到权限描述信息实体 ACISession 
                //    }
                //    //11.将实体信息ACISession添加到纬度列表
                //    aci.ACISessions.Items.Add(acisession);
                //}
                //#endregion

                #region PreContract

                aci.ACISessions = new ACISessions();

                ACISession acisession = new ACISession();

                BEGDC.PreContract.BLL.IEmployee employeeService = (BEGDC.PreContract.BLL.IEmployee)BEGDC.Utility.Castle.AppContainer.Instance[BEGDC.PreContract.BLL.Services.CONST_Employee_Service];
                BEGDC.PreContract.DAL.Employee employee = employeeService.GetEmployee(Convert.ToInt32(aci.AccountInfo.AppAccount));

                if (employee == null)
                {
                    IAM.Interface.Common.Abnormity.ResponseException exception = new IAM.Interface.Common.Abnormity.ResponseException();
                    exception.StatusCode = 600;
                    throw exception;
                }

                #region Role
                //Role
                BEGDC.PreContract.BLL.IUserRole userroleService = (BEGDC.PreContract.BLL.IUserRole)BEGDC.Utility.Castle.AppContainer.Instance[BEGDC.PreContract.BLL.Services.CONST_UserRole_Service];
                System.Data.DataTable dtRole = userroleService.GetUserRole_DataTable( string.Format( " {0} = {1}", BEGDC.PreContract.DAL.UserRole.CONST_EmployeeID ,employee.EmployeeID.ToString()));
                foreach(System.Data.DataRow dr in dtRole.Rows)
                {
                    CheckedItem ci = new CheckedItem();
                    ci.ACItemID = ResponseLocalLibrary.Business.Prefix_Dimension.Role.ToString() + "_" + dr[BEGDC.PreContract.DAL.UserRole.CONST_RoleID].ToString();
                    ci.Value=true;
                    acisession.Items.Add(ci);
                }
                #endregion

                #region BD
                //BD
                BEGDC.PreContract.BLL.IBDAssignment bdService = (BEGDC.PreContract.BLL.IBDAssignment)BEGDC.Utility.Castle.AppContainer.Instance[BEGDC.PreContract.BLL.Services.CONST_BDAssignment_Service];
                System.Data.DataTable dtBD = bdService.GetBDAssignment_DataTable(string.Format(" {0} = {1}", BEGDC.PreContract.DAL.BDAssignment.CONST_EmployeeID, employee.EmployeeID.ToString()));
                foreach(System.Data.DataRow dr in dtBD.Rows)
                {
                    CheckedItem ci = new CheckedItem();
                    ci.ACItemID = ResponseLocalLibrary.Business.Prefix_Dimension.BD.ToString() + "_" + dr[BEGDC.PreContract.DAL.BDAssignment.CONST_BDID].ToString();
                    ci.Value=true;
                    acisession.Items.Add(ci);
                }
                #endregion

                #region CAT
                //CAT
                BEGDC.PreContract.BLL.ICATAssignment catService = (BEGDC.PreContract.BLL.ICATAssignment)BEGDC.Utility.Castle.AppContainer.Instance[BEGDC.PreContract.BLL.Services.CONST_CATAssignment_Service];
                System.Data.DataTable dtCAT = catService.GetCATAssignment_DataTable(string.Format(" {0} = {1}", BEGDC.PreContract.DAL.CATAssignment.CONST_EmployeeID, employee.EmployeeID.ToString()));
                foreach (System.Data.DataRow dr in dtCAT.Rows)
                {
                    CheckedItem ci = new CheckedItem();
                    ci.ACItemID = ResponseLocalLibrary.Business.Prefix_Dimension.CAT.ToString() + "_" + dr[BEGDC.PreContract.DAL.CATAssignment.CONST_CATID].ToString();
                    ci.Value = true;
                    acisession.Items.Add(ci);
                }

                #endregion

                #region Province
                //Province
                BEGDC.PreContract.BLL.IProvinceAssignment provinceService = (BEGDC.PreContract.BLL.IProvinceAssignment)BEGDC.Utility.Castle.AppContainer.Instance[BEGDC.PreContract.BLL.Services.CONST_ProvinceAssignment_Service];
                System.Data.DataTable dtProvince = provinceService.GetProvinceAssignment_DataTable(string.Format(" {0} = {1}", BEGDC.PreContract.DAL.ProvinceAssignment.CONST_EmployeeID, employee.EmployeeID.ToString()));
                foreach (System.Data.DataRow dr in dtProvince.Rows)
                {
                    CheckedItem ci = new CheckedItem();
                    ci.ACItemID = ResponseLocalLibrary.Business.Prefix_Dimension.Province.ToString() + "_" + dr[BEGDC.PreContract.DAL.ProvinceAssignment.CONST_ProvinceID].ToString();
                    ci.Value = true;
                    acisession.Items.Add(ci);
                }
                #endregion

                #region ASBOrLucent

                CheckedItem ci_ASBOrLucent = new CheckedItem();
                ci_ASBOrLucent.ACItemID = ResponseLocalLibrary.Business.Prefix_Dimension.ASBOrLucent.ToString() + "_" + employee.ASBOrLucent.ToString();
                ci_ASBOrLucent.Value = true;
                acisession.Items.Add(ci_ASBOrLucent);

                #endregion

                #region Comment

                if (employee.CommentAllowed)
                {
                    CheckedItem ci_Comment = new CheckedItem();
                    ci_Comment.ACItemID = ResponseLocalLibrary.Business.Prefix_Dimension.Comment.ToString() + "_" + Convert.ToInt32(employee.CommentAllowed).ToString();
                    ci_Comment.Value = true;
                    acisession.Items.Add(ci_Comment);
                }
                #endregion

                #region Download

                if (employee.DownloadAllowed)
                {
                    CheckedItem ci_Download = new CheckedItem();
                    ci_Download.ACItemID = ResponseLocalLibrary.Business.Prefix_Dimension.Download.ToString() + "_" + Convert.ToInt32(employee.DownloadAllowed).ToString();
                    ci_Download.Value = true;
                    acisession.Items.Add(ci_Download);
                }
                #endregion

                aci.ACISessions.Items.Add(acisession);

                #endregion
            }
            catch
            {
                //aci.ACISessions = new ACISessions();

                //ACISession aci1 = new ACISession();

                //CheckedItem ci1 = new CheckedItem();
                //ci1.ACItemID = "Project Manager";
                //ci1.Value=true;
                //aci1.Items.Add(ci1);

                //CheckedItem ci2 = new CheckedItem();
                //ci2.ACItemID = "G007";
                //ci2.Value = true;
                //aci1.Items.Add(ci2);


                //ACISession aci2 = new ACISession();

                //CheckedItem ci3 = new CheckedItem();
                //ci3.ACItemID = "Department Manager";
                //ci3.Value = true;
                //aci2.Items.Add(ci3);

                //CheckedItem ci4 = new CheckedItem();
                //ci4.ACItemID = "D010";
                //ci4.Value = true;
                //aci2.Items.Add(ci4);


                //CheckedItem ci5 = new CheckedItem();
                //ci5.ACItemID = "上海";
                //ci5.Value = true;
                //aci2.Items.Add(ci5);

                //aci.ACISessions.Items.Add(aci1);
                //aci.ACISessions.Items.Add(aci2);

            }

            //12.返回人员权限对象
            return aci;

        }
        #endregion
        #region 设置用户权限信息
        /// <summary>
        /// 设置用户权限信息
        /// 请参考GetUserACI方法中的示例
        /// </summary>
        /// <param name="acifromrequest">用户的权限信息</param>
        /// <returns>设置后用户权限信息</returns>
        public ACI SetUserACI(ACI acifromrequest)
        {

            if (acifromrequest.AccountInfo.AppAccount == string.Empty)
            {
                throw new Exception("AppAccount can not be empty.");
            }


            ////1.声明一个人员权限对象 aci
            //ACI aci = new ACI();
            ////2.实例化aci.人员帐号对象 
            //aci.AccountInfo = new AccountInfo();
            ////3.用带入参数为aci.人员帐号对象 赋值
            //aci.AccountInfo.HRISEID = acifromrequest.AccountInfo.HRISEID;
            //aci.AccountInfo.ADAccount = acifromrequest.AccountInfo.ADAccount;
            //aci.AccountInfo.CSLAccount = acifromrequest.AccountInfo.CSLAccount;
            //aci.AccountInfo.CILX500 = acifromrequest.AccountInfo.CILX500;
            //aci.AccountInfo.UPI = acifromrequest.AccountInfo.UPI;
            //aci.AccountInfo.AppAccount = acifromrequest.AccountInfo.AppAccount;

            ////3.声明aci.纬度列表 ACISessions 
            //aci.ACISessions = new ACISessions();
            ////4. 获取本系统该人员的所有角色集合Roles
            ////4.【说明】角色集合Roles可能是个dataset/datatable/arrylist；由各系统自己组织
            //try
            //{
            //    #region 此段伪代码不能执行，仅仅作为说明

            //    DataSet dsRoles = new DataSet();

            //    //5.遍历Roles集合
            //    for (int i = 0; i < dsRoles.Tables[0].Rows.Count; i++)
            //    {

            //        //6. 声明一个权限描述信息实体 ACISession 
            //        //6 【说明1】如果权限模型为多权限区则可能包括多条权限描述信息ACSession
            //        //6 【说明2】本示例中权限模型为多权限区MultiSection=”TRUE”
            //        //6 【说明3】本示例中设置2个权限区 角色/访问区域
            //        ACISession acisession = new ACISession();
            //        //7.声明一个 权限配置项 CheckedItem ，填充“角色”的权限配置项信息
            //        CheckedItem checkeditemrole = new CheckedItem();
            //        //7.1 权限配置项标识 ACItemID
            //        checkeditemrole.ACItemID = dsRoles.Tables[0].Rows[i]["ACItemID"].ToString();//各个系统根据情况查找不同的字段信息
            //        //7.2 Value 目前均为“check”
            //        if (dsRoles.Tables[0].Rows[i]["Value"].ToString().ToLower() == "true")//各个系统根据情况查找不同的字段信息
            //        {
            //            checkeditemrole.Value = true;
            //        }
            //        else
            //        {
            //            checkeditemrole.Value = false;
            //        }
            //        acisession.Items.Add(checkeditemrole);//将角色权限配置项添加到权限描述信息实体 ACISession 

            //        //8.根据当前的角色信息获取该角色的访问区域集合DataArrylist
            //        DataSet datasetDataArrylist = new DataSet();//
            //        //9.遍历 访问区域集合DataArrylist
            //        for (int j = 0; j < datasetDataArrylist.Tables[0].Rows.Count; j++)
            //        {
            //            //10.声明一个 权限配置项 CheckedItem ，填充“角色”的权限配置项信息
            //            CheckedItem checkeditemData = new CheckedItem();
            //            //10.1 权限配置项标识 ACItemID
            //            checkeditemData.ACItemID = datasetDataArrylist.Tables[0].Rows[j]["ACItemID"].ToString();//各个系统根据情况查找不同的字段信息
            //            //10.2 Value 目前均为“check”
            //            if (datasetDataArrylist.Tables[0].Rows[j]["Value"].ToString().ToLower() == "true")//各个系统根据情况查找不同的字段信息
            //            {
            //                checkeditemData.Value = true;
            //            }
            //            else
            //            {
            //                checkeditemData.Value = false;
            //            }
            //            acisession.Items.Add(checkeditemData);//将访问区域权限配置项添加到权限描述信息实体 ACISession 
            //        }
            //        //11.将实体信息ACISession添加到纬度列表
            //        aci.ACISessions.Items.Add(acisession);
            //    }
            //    #endregion
            //}
            //catch
            //{
            //    aci.ACISessions = new ACISessions();

            //    ACISession aci1 = new ACISession();

            //    CheckedItem ci1 = new CheckedItem();
            //    ci1.ACItemID = "Project Manager";
            //    ci1.Value = true;
            //    aci1.Items.Add(ci1);

            //    CheckedItem ci2 = new CheckedItem();
            //    ci2.ACItemID = "G007";
            //    ci2.Value = true;
            //    aci1.Items.Add(ci2);


            //    ACISession aci2 = new ACISession();

            //    CheckedItem ci3 = new CheckedItem();
            //    ci3.ACItemID = "Department Manager";
            //    ci3.Value = true;
            //    aci2.Items.Add(ci3);

            //    CheckedItem ci4 = new CheckedItem();
            //    ci4.ACItemID = "D010";
            //    ci4.Value = true;
            //    aci2.Items.Add(ci4);


            //    CheckedItem ci5 = new CheckedItem();
            //    ci5.ACItemID = "上海";
            //    ci5.Value = true;
            //    aci2.Items.Add(ci5);

            //    aci.ACISessions.Items.Add(aci1);
            //    aci.ACISessions.Items.Add(aci2);

            //}

            ////12.返回人员权限对象

            #region PreContract


            BEGDC.PreContract.BLL.IEmployee employeeService = (BEGDC.PreContract.BLL.IEmployee)BEGDC.Utility.Castle.AppContainer.Instance[BEGDC.PreContract.BLL.Services.CONST_Employee_Service];
            BEGDC.PreContract.DAL.Employee employee = employeeService.GetEmployee(Convert.ToInt32(acifromrequest.AccountInfo.AppAccount));

            if (employee == null)
            {
                IAM.Interface.Common.Abnormity.ResponseException exception = new IAM.Interface.Common.Abnormity.ResponseException();
                exception.StatusCode = 600;
                throw exception;
            }

            if (acifromrequest.ACISessions.Items.Count == 0)
                return acifromrequest;

            try
            {
                BEGDC.PreContract.BLL.IUserRole userroleService = (BEGDC.PreContract.BLL.IUserRole)BEGDC.Utility.Castle.AppContainer.Instance[BEGDC.PreContract.BLL.Services.CONST_UserRole_Service];
                userroleService.DeleteUserRoleByEmployeeId(employee.EmployeeID);

                BEGDC.PreContract.BLL.IBDAssignment bdService = (BEGDC.PreContract.BLL.IBDAssignment)BEGDC.Utility.Castle.AppContainer.Instance[BEGDC.PreContract.BLL.Services.CONST_BDAssignment_Service];
                bdService.DeleteAllAssignment(employee.EmployeeID.ToString());

                BEGDC.PreContract.BLL.ICATAssignment catService = (BEGDC.PreContract.BLL.ICATAssignment)BEGDC.Utility.Castle.AppContainer.Instance[BEGDC.PreContract.BLL.Services.CONST_CATAssignment_Service];
                catService.DeleteAllAssignment(employee.EmployeeID.ToString());

                BEGDC.PreContract.BLL.IProvinceAssignment provinceService = (BEGDC.PreContract.BLL.IProvinceAssignment)BEGDC.Utility.Castle.AppContainer.Instance[BEGDC.PreContract.BLL.Services.CONST_ProvinceAssignment_Service];
                provinceService.DeleteAllAssignment(employee.EmployeeID.ToString());


                foreach (ACISession acisession in acifromrequest.ACISessions.Items)
                {
                    #region Role
                    //Role

                    foreach (CheckedItem ci in acisession.Items)
                    {
                        if (ci.ACItemID.StartsWith(ResponseLocalLibrary.Business.Prefix_Dimension.Role.ToString()))
                        {
                            if (ci.Value)
                            {
                                BEGDC.PreContract.DAL.UserRole userrole = new BEGDC.PreContract.DAL.UserRole();
                                userrole.EmployeeID = employee;
                                BEGDC.PreContract.DAL.Role role = new BEGDC.PreContract.DAL.Role();
                                role.RoleID = Convert.ToInt32(ci.ACItemID.Substring(ResponseLocalLibrary.Business.Prefix_Dimension.Role.ToString().Length + 1));
                                userrole.RoleID = role;
                                userrole.Create();
                            }
                        }
                    }

                    #endregion

                    #region BD
                    //BD

                    foreach (CheckedItem ci in acisession.Items)
                    {
                        if (ci.ACItemID.StartsWith(ResponseLocalLibrary.Business.Prefix_Dimension.BD.ToString()))
                        {
                            if (ci.Value)
                            {
                                BEGDC.PreContract.DAL.BDAssignment bdassignment = new BEGDC.PreContract.DAL.BDAssignment();
                                bdassignment.EmployeeID = employee;
                                BEGDC.PreContract.DAL.BD bd = new BEGDC.PreContract.DAL.BD();
                                bd.BDID = Convert.ToInt32(ci.ACItemID.Substring(ResponseLocalLibrary.Business.Prefix_Dimension.BD.ToString().Length + 1));
                                bdassignment.BDID = bd;
                                bdassignment.Create();
                            }
                        }
                    }
                    #endregion

                    #region CAT
                    //CAT

                    foreach (CheckedItem ci in acisession.Items)
                    {
                        if (ci.ACItemID.StartsWith(ResponseLocalLibrary.Business.Prefix_Dimension.CAT.ToString()))
                        {
                            if (ci.Value)
                            {
                                BEGDC.PreContract.DAL.CATAssignment catassignment = new BEGDC.PreContract.DAL.CATAssignment();
                                catassignment.EmployeeID = employee;
                                BEGDC.PreContract.DAL.CAT cat = new BEGDC.PreContract.DAL.CAT();
                                cat.CATID = Convert.ToInt32(ci.ACItemID.Substring(ResponseLocalLibrary.Business.Prefix_Dimension.CAT.ToString().Length + 1));
                                catassignment.CATID = cat;
                                catassignment.Create();
                            }
                        }
                    }

                    #endregion

                    #region Province
                    //Province
                    foreach (CheckedItem ci in acisession.Items)
                    {
                        if (ci.ACItemID.StartsWith(ResponseLocalLibrary.Business.Prefix_Dimension.Province.ToString()))
                        {
                            if (ci.Value)
                            {
                                BEGDC.PreContract.DAL.ProvinceAssignment provinceassignment = new BEGDC.PreContract.DAL.ProvinceAssignment();
                                provinceassignment.EmployeeID = employee;
                                BEGDC.PreContract.DAL.Province province = new BEGDC.PreContract.DAL.Province();
                                province.ProvinceID = Convert.ToInt32(ci.ACItemID.Substring(ResponseLocalLibrary.Business.Prefix_Dimension.Province.ToString().Length + 1));
                                provinceassignment.ProvinceID = province;
                                provinceassignment.Create();
                            }
                        }
                    }
                    #endregion

                    #region ASBOrLucent

                    employee.ASBOrLucent = 2;
                    foreach (CheckedItem ci in acisession.Items)
                    {
                        if (ci.ACItemID.StartsWith(ResponseLocalLibrary.Business.Prefix_Dimension.ASBOrLucent.ToString()))
                        {
                            if (ci.Value)
                            {
                                employee.ASBOrLucent = Convert.ToInt32(ci.ACItemID.Substring(ResponseLocalLibrary.Business.Prefix_Dimension.ASBOrLucent.ToString().Length + 1));
                            }
                        }
                    }

                    #endregion

                    #region Comment

                    employee.CommentAllowed = false;
                    foreach (CheckedItem ci in acisession.Items)
                    {
                        if (ci.ACItemID.StartsWith(ResponseLocalLibrary.Business.Prefix_Dimension.Comment.ToString()))
                        {
                            if (ci.Value)
                            {
                                employee.CommentAllowed = true;
                            }
                        }
                    }
                    #endregion

                    #region Download

                    employee.DownloadAllowed = false;
                    foreach (CheckedItem ci in acisession.Items)
                    {
                        if (ci.ACItemID.StartsWith(ResponseLocalLibrary.Business.Prefix_Dimension.Download.ToString()))
                        {
                            if (ci.Value)
                            {
                                employee.DownloadAllowed = true;
                            }
                        }
                    }
                    #endregion
                }

                employee.Active = true;
                employee.Update();
            }
            catch(Exception e)
            {
                string msg = e.Message;
                IAM.Interface.Common.Abnormity.ResponseException exception = new IAM.Interface.Common.Abnormity.ResponseException();
                exception.StatusCode = 610;
                throw exception;
            }

            #endregion

            ResponseLocalLibrary.Business.CreateLog(BEGDC.PreContract.BLL.OperationLog.OperationType.IAM, "SetUserACI:" + acifromrequest.AccountInfo.ADAccount, "IAM");

            return acifromrequest;

        }
        #endregion

        public UserACIs GetAllUserACI()
        {
            BEGDC.PreContract.BLL.IEmployee employeeService = (BEGDC.PreContract.BLL.IEmployee)BEGDC.Utility.Castle.AppContainer.Instance[BEGDC.PreContract.BLL.Services.CONST_Employee_Service];
            System.Data.DataTable dt = employeeService.GetEmployee_DataTable(string.Format(" {0} = 1 ", BEGDC.PreContract.DAL.Employee.CONST_Active));

            UserACIs acis = new UserACIs();
            foreach (System.Data.DataRow dr in dt.Rows)
            {
                AccountInfo user = new AccountInfo();

                
                user.ADAccount = dr[BEGDC.PreContract.DAL.Employee.CONST_ADAccount].ToString();
                
                user.CILX500= dr[BEGDC.PreContract.DAL.Employee.CONST_CILAccount].ToString();
                user.UPI=dr[BEGDC.PreContract.DAL.Employee.CONST_Badge].ToString();
                user.AppAccount = dr[BEGDC.PreContract.DAL.Employee.CONST_EmployeeID].ToString();

                UserACI aci = new UserACI();
                aci.AccountInfo = user;
                aci.ACISessions = this.GetUserACI(user).ACISessions;
                acis.Items.Add(aci);

            }

            return acis;

        }
        #endregion
    }
}
